global umbralizar_asm
section.text
umbralizar_asm:
push ebp
mov ebp, esp
sub esp, 4
push ebx
push edi
push esi
mov esi, [ebp + 8] ;esi <- puntero matriz
mov ecx, [ebp + 12] ; ecx <- filas
mov ebx, [ebp + 16] ; ebx <- columnas
mov eax, ebx  ; eax <- columnas
mov edi, 3 ; edi <- 3
mul dword edi ; eax <- eax * 3
mov edi, eax  ; edi <- 3*columnas (numero de bytes)
and eax, 0x00000003 ; eax <- eax % 4
mov dl, 4   ; dl <- 4
sub dl, al  ; dl = 4 - al (lo q hay q sumar para que sea multiplo de 4)
mov al, dl  ;al = dl
and eax, 0x00000003  ;eax <- dl
mov [ebp - 4], eax   ; [ebp -4 ] <- offset
add edi, eax ; edi <- 3*columnas + offset
xor eax, eax  ; eax <- 0
mov eax, [ebp + 20] ;eax <- umbral superior
mov ebx, [ebp + 24] ; ebx <- umbral inferior
and eax, 0x000000FF ;eax <- al
shl eax, 8          ;ah = al, al = 0
mov al, bl  ; al <- umbral inferior


;Se recorren todos los pixeles buscando aquellos con valor mayor que el umbral
;superior
ciclo1: mov ebx, [ebp + 16]
        ciclo2: cmp ebx, 0
                je finCiclo2
                cmp [esi], ah
                jbe siguiente
                cmp byte [esi], 255
                je siguiente
                mov byte [esi], 0xFF
                mov byte [esi + 1], 0xFF
                mov byte [esi + 2], 0xFF
                siguiente:
                dec ebx
                add esi, 3
                jmp ciclo2

                
        finCiclo2: add esi, [ebp - 4]
                   loop ciclo1
                    
;en este momento todos los mayores al umbral superior estan saturados a 255    
;se buscan los pixeles con valor mayor al umbral inferiro. luego se decide si
;borde o no segun sus vecinos, si lo es se setea el flag de encontreUno en la
;iteracion.     
arrancar: mov esi, [ebp + 8]
          mov ecx, [ebp + 12]
          add esi, edi ;no trato la primer fila
          dec ecx
          mov dh, 0

ciclo1h:  mov ebx, [ebp + 16]
          dec ebx
          add esi, 3
ciclo2h:  cmp ebx, 0
          je finCiclo2h
          cmp ebx, 1
          je pasarProxFila
          cmp byte [esi], 255
          je proximo
          cmp [esi], al
          jae puedeSer
proximo:  add esi, 3
          dec ebx
          jmp ciclo2h  
pasarProxFila: add esi, 3
               add esi, [ebp - 4]
               dec ebx
               jmp ciclo2h
finCiclo2h: cmp ecx, 2
            je finalizo                          
            loop ciclo1h
            jmp finalizo
puedeSer: cmp byte [esi + 3], 255
          je era   
          cmp byte [esi - 3], 255
          je era 
          cmp byte [esi + edi], 255
          je era 
          cmp byte [esi + edi + 3], 255
          je era  
          cmp byte [esi + edi - 3], 255
          je era
          sub esi, edi
          cmp byte [esi +3], 255
          je sumaYera
          cmp byte [esi -3], 255
          je sumaYera
          cmp byte [esi], 255
          je sumaYera
          add esi, edi
          jmp proximo
sumaYera:  add esi, edi
era:      mov byte [esi], 255
          mov byte [esi + 1], 255
          mov byte [esi + 2], 255
          mov dh, 1
          jmp proximo
          
;si toque alguno en esta iteracion, reinicio el ciclo. sino seteo en cero a los
;q no son borde     
finalizo: cmp dh, 1
          je arrancar
;a partir de aca pongo en cero a los q no son
          mov esi, [ebp + 8]
          mov ecx, [ebp + 12]
          add esi, edi ;no trato la primer fila
          dec ecx
ciclo1F:  mov ebx, [ebp + 16]
          dec ebx
          add esi, 3
ciclo2F:  
cmp ebx, 0
je finCiclo2F
cmp ebx, 1
je pasarProxFilaF   
cmp byte [esi], 0
je next
cmp byte [esi], 255
je next
mov byte [esi], 0
mov byte [esi + 1], 0
mov byte [esi + 2], 0
next:  
add esi, 3
dec ebx
jmp ciclo2F
pasarProxFilaF:
                add esi, 3
                add esi, [ebp - 4]
                dec ebx
                jmp ciclo2F
finCiclo2F: 
cmp ecx, 2
            je final                          
            loop ciclo1F
            jmp final
final:
          pop esi
          pop edi
          pop ebx
          add esp, 4
          pop ebp
          ret
          